package com.cloudbroker.bcs.common.auth;

import java.util.Collection;

import com.cloudbroker.bcs.common.util.CacheHelper;
import com.cloudbroker.bcs.common.util.ExtendAppCodeConvert;
import com.cloudbroker.bcs.common.util.SessionHelper;
import com.cloudbroker.bcs.common.util.StringUtil;

public class AuthUtil {
    
    public static final String PERMISSION_LEVEL_DELIMITER = ".";
    
    public static final String PERMISSION_WILDCARD_SIBLING = "*";
    
    public static final String PERMISSION_WILDCARD_DESCENDANT = "**";
    
    public static final String PERMISSION_ANONYMOUS = "anon";
    
    /**
     * 是否拥有要求的权限
     * @param ownPermissions 拥有的权限
     * @param requiredPermissions 要求的权限（各权限中是且的关系）
     * @return
     */
    public static boolean hasPermission(Collection<String> ownPermissions, String... requiredPermissions) {
        // 没有需求的权限，则鉴权通过
        if (null == requiredPermissions || 0 == requiredPermissions.length) {
            return true;
        }
        // 为匿名权限，则鉴权通过（只需检查第一个，因为要求的权限为且的关系，第一个不符合则整体是非匿名要求）
        if (PERMISSION_ANONYMOUS.equals(requiredPermissions[0])) {
            return true;
        }
        // 没有拥有的权限，则鉴权失败
        if (null == ownPermissions || ownPermissions.isEmpty()) {
            return false;
        }
        // 遍历要求的权限
        for (String requiredPermission : requiredPermissions) {
            // 如果单个要求的权限鉴权失败，则整体鉴权失败
            if (!checkSinglePermission(ownPermissions, requiredPermission)) {
                return false;
            }
        }
        return true;
    }
    
    private static boolean checkSinglePermission(Collection<String> ownPermissions, String requiredPermission) {
        // 先通过set的contains查找，以求hashset可以尽快命中
        if (ownPermissions.contains(requiredPermission)) {
            return true;
        }
        // 如果找不到，检查通配符
        // 遍历拥有的权限
        for (String ownPermission : ownPermissions) {
            // 检查后代通配符
            int wildcardIdx = ownPermission.indexOf(PERMISSION_WILDCARD_DESCENDANT);
            if (-1 != wildcardIdx) {
                // 如果找到后代通配符
                // 截取通配符之前的作为前缀匹配要求的权限
                String permissionPrefix = ownPermission.substring(0, wildcardIdx);
                // 如果要求的权限以此开头，则该要求权限鉴权成功
                if (requiredPermission.startsWith(permissionPrefix)) {
                    return true;
                }
            } else {
                // 如果找不到后代通配符
                // 检查同级通配符
                wildcardIdx = ownPermission.indexOf(PERMISSION_WILDCARD_SIBLING);
                if (-1 != wildcardIdx) {
                    // 如果找到同级通配符
                    // 截取通配符之前的作为前缀匹配要求的权限
                    String permissionPrefix = ownPermission.substring(0, wildcardIdx);
                    // 如果要求的权限以此开头，而且在此前缀以后找不到级别分隔符，则该要求权限鉴权成功
                    if (requiredPermission.startsWith(permissionPrefix)
                            && -1 == ownPermission.indexOf(PERMISSION_LEVEL_DELIMITER, wildcardIdx)) {
                        return true;
                    }
                }
            }
        }
        // 如果拥有的权限遍历完毕还是不匹配，返回鉴权失败
        return false;
    }
    
    public static boolean hasBuyedExtendApps(String [] codes,String [] apps){
        // 没有权限 鉴权不通过
        if (null == apps || 0 == apps.length) {
            return false;
        }
        // 为匿名权限，则鉴权通过（只需检查第一个，因为要求的权限为且的关系，第一个不符合则整体是非匿名要求）
        if (PERMISSION_ANONYMOUS.equals(apps[0])) {
            return true;
        }
        // 没有需要权限，则鉴权通过
        if (codes == null) {
            return true;
        }
        // 遍历要求的权限
        for (String code : codes) {
            code = ExtendAppCodeConvert.getFansCode(code);
        	if(code == null){
        	    return true;
        	} else if(!checkSingleCode(code, apps)){
        		return false;
        	}
		}
        return true;
    }
    
    public static boolean isNeedLoginExtendApps(String [] codes,String [] apps){
        // 没有需要登录的组件 通过
        if (null == apps || 0 == apps.length) {
            return true;
        }
        // 为匿名权限，则鉴权通过（只需检查第一个，因为要求的权限为且的关系，第一个不符合则整体是非匿名要求）
        if (PERMISSION_ANONYMOUS.equals(apps[0])) {
            return true;
        }
        // 没有需要权限，则鉴权通过
        if (codes == null) {
            return true;
        }
        // 遍历要求的权限
        for (String code : codes) {
            code = ExtendAppCodeConvert.getFansCode(code);
            if(checkSingleCode(code, apps)){
                return false;
            }
        }
        return true;
    }
    
    public static boolean checkSingleCode(String code,String [] apps){
        for (String app : apps) {
            if(app.equals(code)){
                return true;
            }
        }
        return false;
    }
}
